home *** CD-ROM | disk | FTP | other *** search
/ The X-Philes (2nd Revision) / The X-Philes Number 1 (1995).iso / xphiles / hp48hor2 / rpl8.doc < prev    next >
Text File  |  1995-03-31  |  9KB  |  171 lines
  1. RPL.DOC by Joe Horn 
  2.  
  3. People keep asking, "What Exactly *Is* RPL, Anyway?" 
  4.  
  5. RPL is not an "interpreted" language like early implementations of BASIC (the 
  6. slowest way of doing things), nor a "tokenized" language like HP BASIC 
  7. (speeds up the interpreter), nor a "p-code" language like PASCAL (a little 
  8. better than an interpreter) nor a "compiled" language like FORTRAN or C (the 
  9. best a high-level language can get). It's instead a "threaded" language like 
  10. LISP and FORTH. 
  11.  
  12. What does that mean?  When you type a program, the command names that you 
  13. typed are not stored; nor are "tokens" that correspond to them in some sort 
  14. of lookup table.  Instead, only the *memory addresses* of each command are 
  15. stored in your program.  Running RPL programs is therefore very efficient; 
  16. the HP 48 just does a "gosub" to each address.  No time is wasted looking up 
  17. command names or token addresses. 
  18.  
  19. Of course, each of these addresses may in fact be just another program full 
  20. of jumps to other addresses, which in turn may be programs... and so on.  A 
  21. return stack keeps track of everything, and unlike the HP-41 and all earlier 
  22. HP programmable calculators, the return stack is not a fixed size, but can 
  23. grow as needed.  Obviously, however, this "thread" must bottom out at some 
  24. sort of primitive, non-threaded programs, and these are either written in 
  25. machine language, or are data objects which merely place themselves on the 
  26. stack (like pi). 
  27.  
  28. A good question is: If RPL programs only contain memory addresses, how can 
  29. they be edited and printed?  When you edit or print a program, the HP 48 
  30. looks at the memory immediately preceeding each address to find out the 
  31. command's name, and displays/prints that.  Of course, this assumes that all 
  32. commands have names. 
  33.  
  34. Now, what would happen if HP included a command in the operating system, but 
  35. forgot to give it a name?  Then it would work okay inside an RPL program, but 
  36. you couldn't edit that program, print it, or type that command on the command 
  37. line.  Guess what: the HP 48 has well over two thousand commands that have no 
  38. names. 
  39.  
  40. A distinction must now be made between two kinds of RPL: User RPL and System 
  41. RPL.  User RPL is the language that the Owner's Manual tells you about, the 
  42. language you see on the keyboard and in the menus, and which Joe Average 
  43. uses; it's "the << >> language".  But this is only a small subset of a much 
  44. richer language with a vocabulary thousands of words larger, called System 
  45. RPL.  Unfortunately, all the System RPL words are "nameless objects", which 
  46. means that they cannot be edited or listed.  Any attempt to edit or list a 
  47. System RPL program usually results in "External" being displayed (the default 
  48. name for a nameless object), but sometimes results in other displays, or even 
  49. system malfunction. 
  50.  
  51. If it's such a pain, why write in System RPL?  Because it runs way faster and 
  52. it's more powerful than User RPL.  Most of the nifty features of the HP 48 
  53. operating system itself are written in System RPL. 
  54.  
  55. But how can you write System RPL if the objects have no names?  Well, they 
  56. have no names inside the HP 48 itself, but they do have names; the design 
  57. team of the HP 48 has "in-house" names for all of them. (It's sorta like the 
  58. parts of your body for which you don't know the name; they do have names, 
  59. even if the names don't happen to be stored in your brain.)  For example the 
  60. System RPL program at address #30794h, which pushes the version string of 
  61. your HP 48 onto the stack, is called VERSTRING by HP, but that name is not 
  62. stored in the HP 48 anywhere.  The name is stored in external software. 
  63.  
  64. For example, this User RPL program (which yields your ROM revision letter): 
  65.  
  66.     << #30794h SYSEVAL 8 8 SUB >>           (33 bytes; .020 seconds to run) 
  67.  
  68. can be written in System RPL this way: 
  69.  
  70.     :: VERSTRING EIGHT LAST$ ;            (12.5 bytes; .011 seconds to run) 
  71.  
  72. The HP 48 development team used computers to write HP 48 "programs" using 
  73. these in-house names.  The computers then used huge lookup tables to 
  74. translate them and create real HP 48 downloadable programs. The entire 
  75. operating system (256K of code!), the HP Solve Equation Library Card, and 
  76. several third-party commercial software packages were developed entirely on 
  77. computers this way. 
  78.  
  79. And you can do it too!  HP has made a System RPL Development Tools package 
  80. available.  Get TOOLS.EXE from your favorite ftp site, or order Goodies Disk 
  81. #4 for $4.95 from EduCALC.  Everything you need is there, including 
  82. well-written documentation for it all. 
  83.  
  84. But the really exciting news is that you don't even need a computer to write 
  85. System RPL any more (and you don't have to be a genius hacker with a 
  86. prodigious memory and infinite patience, like Alonzo Gariepy or Rick 
  87. Grevelle, either!).  Detlef Mueller and Brian Maguire have independently 
  88. developed libraries that effectively replace the built-in User RPL command 
  89. names with HP's in-house System RPL names! So instead of writing 
  90.  
  91.     IF < THEN SWAP DROP ELSE ROT DROP END 
  92.  
  93. in slow User RPL, you can write the equivalent 
  94.  
  95.     %< ITE SWAPDROP ROTDROP 
  96.  
  97. in fast System RPL, right from the HP 48 keyboard! 
  98.  
  99. The DETLEF subdirectory on this disk contain's Detlef Mueller's complete 
  100. System RPL development system and library creator.  It almost obsoletes 
  101. Goodies Disk #4!  Check it out. 
  102.  
  103. Here's a sample of useful System RPL which I just finished today, developed 
  104. entirely on the HP 48 keyboard.  It sorts a list of real numbers into 
  105. ascending order, and it's *fast*, over 400 times faster (!) than HP's SORT 
  106. program in the Owner's Manual (in User RPL, of course) on a list of 100 
  107. numbers: 
  108.  
  109. :: CK1&Dispatch # 5h 
  110.   :: INNERCOMP 1LAMBIND 1GETLAM 
  111.     #1+_ONE_DO 1GETLAM ROLL # 0h INDEX@ 
  112.       BEGIN 2DUP SWAP#- #2/ DUP#0<> 
  113.       WHILE 
  114.         :: OVERSWAP #-DUP #4+PICK 5PICK %> 
  115.           ITE ROTDROPSWAP SWAPDROP 
  116.         ; 
  117.       REPEAT ROT2DROP UNROLL 
  118.     LOOP 1GETABND {}N 
  119.   ; 
  120. ; 
  121.  
  122. It sorts 100 random numbers in 4.5 seconds!  (HP's takes half an hour!)  And 
  123. it's *shorter* than HP's SORT program, too, at only 90 bytes!  Golly. 
  124.  
  125. Unfair comparison, I know; it's the worst algorithm in the most readable User 
  126. RPL versus a better algorithm in almost-unreadable System RPL.  But *still*, 
  127. 400 times faster???  Geez! 
  128.  
  129. [The sorter above is on this disk, called "SORTLN", in the PROGRAMR 
  130. subdirectory.  -jkh-] 
  131.  
  132. But the benefits of System RPL are more than just saving time and memory.  It 
  133. also allows you to do things that User RPL simply cannot do, like work with 
  134. Library Data objects, do math to 15-digit accuracy, use arrays containing 
  135. nonnumeric objects, treat programs as if they were lists (PUT, GET, explode 
  136. onto the stack, and reassemble from the stack), create HP-41-style prefix 
  137. operators (e.g. TONE 8), peek and poke directly into memory, and more. 
  138.  
  139. If you know User RPL, learning System RPL won't take long or be difficult. 
  140. It's just a new vocabulary, not a new way of thinking.  It's *real* RPL. 
  141.  
  142.             User RPL                          System RPL 
  143.  
  144. 1.  To use a command, you just       The commands have no names and can 
  145.     type its name.  The HP 48        only be used with SYSEVAL or by 
  146.     recognizes the name because      directly embedding the "External" 
  147.     it's in the built-in list of     code in a program using various 
  148.     command names.                   System RPL programming tools. 
  149.  
  150. 2.  The commands are safe to use     The commands are dangerous to use 
  151.     because they have built-in       because they assume the stack has 
  152.     argument type checking.          the correct arguments on it, and may 
  153.                                      wipeout if not. 
  154.  
  155. 3.  Slower (because of #2)           Faster (because of #2) 
  156.  
  157. 4.  You can view, print, and edit    The only way to view, print, or edit 
  158.     programs directly on the HP 48   programs is with System RPL 
  159.     without any extra software       developer's software in the HP 48 or 
  160.     needed.                          on a computer. 
  161.  
  162. 5.  You can only handle a few of     You can handle all 29 object types 
  163.     the HP 48's object types.        directly. 
  164.  
  165. 6.  You can only do "supported"      You have total control of the HP 48 
  166.     things in the Manual.            and can do "impossible" things. 
  167.  
  168. 7.  Impresses the natives.           Impresses hackers. 
  169.  
  170. -jkh- 
  171.